// 进程监控排序器
class ProcessSorter {
    constructor() {
        this.currentSortField = null;
        this.currentSortOrder = 'desc';
        this.currentTabType = 'connections'; // 'connections' or 'processes'
    }

    // 设置当前标签页类型
    setTabType(tabType) {
        this.currentTabType = tabType;
    }

    // 点击表头排序
    handleHeaderClick(field) {
        // 如果点击的是当前排序字段，则循环切换状态
        if (this.currentSortField === field) {
            if (this.currentSortOrder === 'asc') {
                // 第二次点击：降序
                this.currentSortOrder = 'desc';
            } else if (this.currentSortOrder === 'desc') {
                // 第三次点击：恢复默认状态（无排序）
                this.currentSortField = null;
                this.currentSortOrder = null;
            }
        } else {
            // 如果是新字段，第一次点击设置为升序
            this.currentSortField = field;
            this.currentSortOrder = 'asc';
        }
        
        // 更新表头样式
        this.updateHeaderStyles();
        
        // 触发重新渲染
        if (window.processMonitor) {
            window.processMonitor.filterAndRenderData();
        }
    }

    // 更新表头样式
    updateHeaderStyles() {
        // 清除所有表头的排序样式
        document.querySelectorAll('.process-table th.sortable').forEach(th => {
            th.classList.remove('active', 'sort-asc', 'sort-desc');
        });
        
        // 为当前排序字段添加样式
        if (this.currentSortField) {
            const activeHeader = document.querySelector(`.process-table th[data-sort="${this.currentSortField}"]`);
            if (activeHeader) {
                activeHeader.classList.add('active');
                activeHeader.classList.add(this.currentSortOrder === 'asc' ? 'sort-asc' : 'sort-desc');
            }
        }
    }

    // 获取排序键值
    getSortValue(item, field) {
        switch (field) {
            case 'process_name':
                return (item.process_name || '').toLowerCase();
            case 'pid':
                return parseInt(item.pid) || 0;
            case 'bytes_sent':
                return item.bytes_sent || 0;
            case 'bytes_recv':
                return item.bytes_recv || 0;
            case 'speed_up':
                return item.speed_up || 0;
            case 'speed_down':
                return item.speed_down || 0;
            case 'total_connections':
                return item.total_connections || 0;
            case 'active_tcp':
                return item.active_tcp || 0;
            case 'active_udp':
                return item.active_udp || 0;
            case 'total_sent':
                return item.total_sent || 0;
            case 'total_recv':
                return item.total_recv || 0;
            default:
                return 0;
        }
    }

    // 排序连接数据
    sortConnections(connections) {
        if (!connections || connections.length === 0 || !this.currentSortField) {
            return connections;
        }

        return [...connections].sort((a, b) => {
            const aValue = this.getSortValue(a, this.currentSortField);
            const bValue = this.getSortValue(b, this.currentSortField);
            
            let result = 0;
            if (typeof aValue === 'string') {
                result = aValue.localeCompare(bValue);
            } else {
                result = aValue - bValue;
            }
            
            return this.currentSortOrder === 'asc' ? result : -result;
        });
    }

    // 排序进程数据
    sortProcesses(processes) {
        if (!processes || processes.length === 0 || !this.currentSortField) {
            return processes;
        }

        return [...processes].sort((a, b) => {
            const aValue = this.getSortValue(a, this.currentSortField);
            const bValue = this.getSortValue(b, this.currentSortField);
            
            let result = 0;
            if (typeof aValue === 'string') {
                result = aValue.localeCompare(bValue);
            } else {
                result = aValue - bValue;
            }
            
            return this.currentSortOrder === 'asc' ? result : -result;
        });
    }

    // 设置表头点击事件监听器
    setupHeaderEventListeners() {
        document.querySelectorAll('.process-table th.sortable').forEach(th => {
            th.addEventListener('click', () => {
                const field = th.getAttribute('data-sort');
                if (field) {
                    this.handleHeaderClick(field);
                }
            });
        });
    }

    // 设置排序类型（兼容旧代码）
    setSortType(sortType) {
        // 这个方法保留以兼容process-events.js中的调用
        console.log('setSortType called:', sortType);
    }

    // 获取当前排序类型（兼容旧代码）
    getCurrentSortType() {
        if (!this.currentSortField) {
            return 'traffic-desc';
        }
        return `${this.currentSortField}-${this.currentSortOrder}`;
    }
}

// 创建全局实例
window.processSorter = new ProcessSorter();

// 页面加载完成后设置事件监听器
document.addEventListener('DOMContentLoaded', () => {
    // 延迟设置，确保表格已经渲染
    setTimeout(() => {
        window.processSorter.setupHeaderEventListeners();
    }, 100);
});